﻿#define  _CRT_SECURE_NO_WARNINGS 1
# include<iostream>
using namespace std;
# include<vector>
# include <map>
# include <string>

//int main()
//{
//	/*struct Date
//	{
//		int year;
//		int month;
//		int day;
//	};
//	int arr[10] = { 5,1,2,3 };*/
//	/*Date d1={ 2025,10,7 };*/
//	
//
//    //  内置类型⽀持
//	int a{ 1 };
//	double b{ 2.2 };
//	char c{ 'a' };
//  
//    class Date
//    {
//    public:
//        Date(int year = 1, int month = 1, int day = 1)
//            :_year(year)
//            , _month(month)
//            , _day(day)
//        {
//            cout << "调用构造函数" << endl;
//        }
//        Date(const Date& d)
//            :_year(d._year)
//            , _month(d._month)
//            , _day(d._day)
//        {
//            cout << "调用拷贝构造函数" << endl;
//        }
//    private:
//        int _year;
//        int _month;
//        int _day;
//    };
//       /* Date d1 = { 2025, 1, 1 };
//        cout << endl;
//        const Date& d2 = { 2024, 7, 25 };*/
//
//       
//
//        //Date d3 = { 2025 };      //c++98支持的单参数隐式类型转换可以去掉{}
//        //Date d4 = 2025;     
//        //Date d33{ 2025 }; //有{}可以省略=
//        //Date d4  2025;     //没有{}不能省略=
//
//
//        Date d1{ 2025, 1, 1 };         //c++11支持的{} 可以省略=
//        //cout << endl;
//        //const Date& d2{ 2024, 7, 25 };
//        //Date d5 = 2025, 1, 1;    //c++11支持的{}  不可以省略{}
//
//
//        vector<Date> v;
//        v.push_back(d1); //直接插入对象的方式
//        v.push_back(Date(2025, 1, 1)); //匿名对象的方式
//        v.push_back({ 2025, 1, 1 });  //{}的方式  相较于前两种 这种方法非常简便
//
//        map<string, string>m1;
//        m1.insert({ "sss","ttt" });
//
//       /* vector<int>vv({ 1,2,3,4,5,6 }); 
//        vector<string>ss({ "hh""ttt""eee" });*/
//
//       /* vector<int>vv({ 1,2,3,4,5,6 });*/
//
//        /*int arr[]= { 1,2,3,4,5,6 };
//        for (int x : arr)
//            vv.push_back(x);*/
//
//        vector<int>vv({ 1,2,3,4,5,6 });   //直接将{}里面内容转换为initia_list 然后进行构造
//
//        vector<int>vv{ 1,2,3,4,5,6 };  //先用{}调用构造 构造了一个临时对象 然后进行拷贝构造  不过编译器最终会优化为直接构造 和上面的一样了就
//
//        map<string, string>m1{{"sss","ttt"},{"sss","ttt"}};
//
//
//
//        return 0;
//}

//int main()
//{
//	
//	//左值  可以取地址
//    int* p = new int(0);
//	int b = 1;
//	const int c = b;
//	*p = 10;
//	string s("111111");
//	s[0] = 'x';       //函数调用 但是返回的是引用 是左值
//	/*cout << &c << endl;
//	cout << (void*)&s[0] << endl;*/
//
//	// 右值：不能取地址
//	double x = 1.1, y = 2.2;
//
//	10;              //常量
//	x + y;             //表达式
//	fmin(x, y);    //函数调用 是传值返回 是右值
//	string("11111"); //匿名对象
//
//	/*cout << &10 << endl;
//    cout << &(x+y) << endl;
//    cout << &(fmin(x, y)) << endl;
//    cout << &string("11111") << endl;*/
//
//	// 左值引⽤给左值取别名
//	//int& r1 = b;
//	//int*& r2 = p;
//	//int& r3 = *p;
//	//string& r4 = s;
//	//char& r5 = s[0];
//	//// 右值引⽤给右值取别名
//	//int&& rr1 = 10;
//	//double&& rr2 = x + y;
//	//double&& rr3 = fmin(x, y);
//	//string&& rr4 = string("11111");
//
//	//// 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值
//	//const int& rx1 = 10;
//	//const double& rx2 = x + y;
//	//const double& rx3 = fmin(x, y);
//	//const string& rx4 = string("11111");
//
//	//// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)
//	//int&& rrx1 = move(b);
//	//int*&& rrx2 = move(p);
//	//int&& rrx3 = move(*p);
//	//string&& rrx4 = move(s);
//
//	//int&& rrx1 = (int&&)b;
//	//int*&& rrx2 = (int*&&)p;
//	//int&& rrx3 = (int&&)*p;
//	//string&& rrx5 = (string&&)s;
//
//	// 这⾥要注意的是，rr1的属性是左值，所以不能再被右值引⽤绑定，除⾮move⼀下
//
//	/*int&& rr1 = move(b);
//	int& r6 = rr1;
//	int&& rrx6 = rr1;
//	int&& rrx6 = move(rr1);*/
//
//	string s1 = "Test";
//	
//	const std::string& r2 = s1 + s1;  //const左值引用延长了s1+s1产生临时对象(右值)的生命周期        
//	//  r2 += "Test";                 //但是因为被const修饰 不能进行修改 
//	
//	string&& r3 = s1 + s1;    //右值引用的方式延长了s1+s1产生临时对象(右值)的生命周期
//	r3 += 'c';                //且可以被修改
//	cout << r3 << '\n';
//}

void f(const int& x)
{
	std::cout << "const的左值引用重载f(" << x << ")\n";
}
void f(int& x)
{
	std::cout << "左值引用重载f(" << x << ")\n";
}

void f(int&& x)
{
	std::cout << "右值引用重载f(" << x << ")\n";
}

//int main()
//{
//	//int i = 1;
//	//const int ci = 2;
//	//f(i);  // f(int&)
//	//f(ci); // 调⽤f(const int&)
//	//f(3);  // 调⽤f(int&&)，如果没有f(int&&)重载则会调⽤f(const int&)
//	//f(std::move(i)); // 调⽤f(int&&)
//
//	//右值引用变量在用于表达式时是左值右值引用本身的属性是左值
//	int&& x = 1;
//	f(x); // 调用 f(int& x)
//	f(move(x)); // 调用 f(int&& x)
//}



//    string&& addStrings(string num1, string num2) {
//        string str;
//        int end1 = num1.size() - 1, end2 = num2.size() - 1;
//        // 进位
//            int next = 0;
//        while (end1 >= 0 || end2 >= 0)
//        {
//            int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
//            int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
//            int ret = val1 + val2 + next;
//            next = ret / 10;
//            ret = ret % 10;
//            str += ('0' + ret);
//        }
//        if (next == 1)
//            str += '1';
//        reverse(str.begin(), str.end());
//        return str;
//    }
//int main()
//  {
//    string s2=addStrings("ssssss", "sdddd");
//    cout << s2;
//  }
# include <assert.h>
namespace xx
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
		/*	cout << "string(char* str)-构造" << endl;*/
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 拷贝构造" << endl;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}

		void swap(string& ss)
		{
			::swap(_str, ss._str);
			::swap(_size, ss._size);
			::swap(_capacity, ss._capacity);
		}

	  // 移动构造
		string(string&& s)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			swap(s);
		}

		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 拷贝赋值" <<
				endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;
				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			}
			return *this;
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}

		~string()
		{
			//cout << "~string() -- 析构" << endl;
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				if (_str)
				{
					strcpy(tmp, _str);
					delete[] _str;
				}
				_str = tmp;
				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity *
					2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}

		size_t size() const
		{
			return _size;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
}
    xx::string addStrings(xx::string num1, xx::string num2) {
        xx::string str;
        int end1 = num1.size() - 1, end2 = num2.size() - 1;
        // 进位
            int next = 0;
        while (end1 >= 0 || end2 >= 0)
        {
            int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
            int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
            int ret = val1 + val2 + next;
            next = ret / 10;
            ret = ret % 10;
            str += ('0' + ret);
        }
        if (next == 1)
            str += '1';
        reverse(str.begin(), str.end());
        return str;
    }
//int main()
//  {
//	xx::string s2;
//	s2 = addStrings("2111", "5555");
//
//
//
//	//这22直接全优化成一个构造了 看不了
//	/*xx::string sss1("555555"), sss2("6666666");*/
//   
//   /* cout << s2.c_str();*/
//  }
////int main()
////{
////	/*xx::string ss("sssssssssss");
////	xx::string s2(ss);
////	xx::string s3(xx::string("llllllll"));
////	xx::string s4("111111111111111");*/
////
////	xx::string ss("sssssssssss");
////	xx::string s2(ss);
////	xx::string s5(move(ss));
////}

# include "list.h"
	/*int main()
	{
		xx::list<int>l1;
		l1.insert(l1.begin(),11);
		l1.push_back(1);
		return 0;
	}*/

	/*int main()
	{
		std::list<xx::string> lt;
		xx::string s1("111111111111111111111");
		lt.push_back(s1);
		cout << "*************************" << endl;
		lt.push_back(xx::string("22222222222222222222222222222"));
		cout << "*************************" << endl;
		lt.push_back("3333333333333333333333333333");
		cout << "*************************" << endl;
		lt.push_back(move(s1));
		cout << "*************************" << endl;
		return 0;
	}*/


	template<class T>
	void f1(T& x)
	{}

	template<class T>
	void f2(T&& x)
	{}

	//int main()
	//{
	//	typedef int& lref;
	//	typedef int&& rref;
	//	int n = 0;
	//	lref& r1 = n;  // r1 的类型是int&
	//	lref&& r2 = n; // r2 的类型是int&
	//	rref& r3 = n;  // r3 的类型是int&
	//	rref&& r4 = 1; // r4 的类型是int&&

	//	// 没有折叠->实例化为void f1(int& x)
	//	f1<int>(n);
	//	//f1<int>(0); // 报错
	//
	//	// 折叠->实例化为void f1(int& x)
	//	f1<int&>(n);
	//	//f1<int&>(0); // 报错
	//
	//	// 折叠->实例化为void f1(int& x)
	//	f1<int&&>(n);
	//	//f1<int&&>(0); // 报错
	//
	//	// 折叠->实例化为void f1(const int& x)
	//	f1<const int&>(n);
	//	f1<const int&>(0);
	//
	//	// 折叠->实例化为void f1(const int& x)
	//	f1<const int&&>(n);
	//	f1<const int&&>(0);
	//
	//	// 没有折叠->实例化为void f2(int&& x)
	//	//f2<int>(n); // 报错
	//	f2<int>(0);
	//
	//	// 折叠->实例化为void f2(int& x)
	//	f2<int&>(n);
	//	//f2<int&>(0); // 报错
	//
	//	// 折叠->实例化为void f2(int&& x)
	//	//f2<int&&>(n); // 报错
	//	f2<int&&>(0);





	//}

		// 万能引用 
	template<class T>
	void Function(T&& t)
	{
		int a = 0;
		T x = a;
		//x++;
	
		cout << &a << endl;
		cout << &x << endl << endl;
	}
	
	int main()
	{
		// 10是右值，推导出T为int，模板实例化为void Function(int&& t)
		/*Function(10);*/
	
		int a;
		// a是左值，推导出T为int&，引用折叠，模板实例化为void Function(int& t)
		//Function(a); // 左值
	
		// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
		/*Function(std::move(a));*/
	
		const int b = 8;
		// b是左值，推导出T为const int&，引用折叠，模板实例化为void Function(const int& t)
		// 所以Function内部会编译报错，x不能++
		//Function(b);    // const 左值
	
		// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
		// 所以Function内部会编译报错，x不能++
		Function(std::move(b)); // const 右值
	
		return 0;
	}